#include "informationword.h"
#include <QDebug>

informationWord::informationWord(QObject *parent) :
    QObject(parent)
{
}

//********************************************************************************
//函数名：pParseSIQ
//功能：解析带品质描述词的单点信息(IEV 371-02-07)(SIQ)
QString informationWord::pParseSIQ(int data_parse)
{
    //        SIQ                    ：=CP8{SPI，RES，BL，SB，NT，IV}
    //        SPI=单点信息    ：=BS1[1]<0..1>
    //                      <0>      ：=开
    //                      <1>      ：=合
    //        RES=RESERVE          ：=BS3[2..4]<0>
    //        BL                     ：=BS1[5]<0..1>
    //                      <0>      ：=未被闭锁
    //                       <1>      ：=被闭锁
    //        SB                     ：=BS1[6]<0..1>
    //                      <0>      ：=未被取代
    //                      <1>      ：=被取代
    //        NT                     ：=BS1[7]<0..1>
    //                      <0>      ：=当前值
    //                      <1>       ：=非当前值
    //        IV                      ：=BS1[8]<0..1>
    //                     <0>        ：=有效
    //                     <1>        ：=无效

    int l_i_IV=data_parse%2;//->8位是低位
    QString l_s_IV;

    if(l_i_IV==0)
        l_s_IV="IV =0  有效 ";
    else
        l_s_IV="IV =1  无效 ";

    //        NT                     ：=BS1[7]<0..1>
    //                      <0>      ：=当前值
    //                      <1>       ：=非当前值

    int l_i_NT=(data_parse>>1)%2;//->7位是右边第二位
    QString l_s_NT;

    if(l_i_NT==0)
        l_s_NT="NT=0 当前值 ";
    else
        l_s_NT="NT=1 非当前值 ";

    //        SB                     ：=BS1[6]<0..1>
    //                      <0>      ：=未被取代
    //                      <1>      ：=被取代

    int l_i_SB=(data_parse>>2)%2;//->6 位是右边第三位
    QString l_s_SB;

    if(l_i_SB==0)
        l_s_SB="SB=0 未被取代 ";
    else
        l_s_SB="SB=1 被取代 ";

    //        BL                     ：=BS1[5]<0..1>
    //                      <0>      ：=未被闭锁
    //                       <1>      ：=被闭锁

    int l_i_BL=(data_parse>>3)%2;//->5位是右边第四位
    QString l_s_BL;

    if(l_i_BL==0)
        l_s_BL="SB=0 被闭锁  ";
    else
        l_s_BL="SB=1 未被闭锁  ";

    //        SPI=单点信息    ：=BS1[1]<0..1>
    //                      <0>      ：=开
    //                      <1>      ：=合

    int l_i_SPI=(data_parse>>7)%2;
    QString l_s_SPI;

    if(l_i_SPI==0)
        l_s_SPI="SPI=0 开  ";
    else
        l_s_SPI="SPI=1 合  ";

    QString l_all="SIQ=CP8{SPI，RES，BL，SB，NT，IV}"+l_s_SPI+l_s_BL+l_s_SB+l_s_NT+l_s_IV;
    //qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseDIQ
//功能：解析带品质描述词的单点信息(IEV 371-02-07)(SIQ)

QString informationWord::pParseDIQ(int data_parse)
{
    //    DIQ                    ：=CP8{DPI，RES，BL，SB，NT，IV}
    //        DPI=双点信息           ：=UI2[1..2]<0..3>                           (Type 1.1)
    //                    <0>        ：=不确定或中间状态
    //                    <1>        ：=确定状态开
    //                    <2>        ：=确定状态合
    //                    <3>        ：=不确定或中间状态
    //        RES=RESERVE         ：=BS2[3..4]<0>                              (Type 6)
    //        BL                     ：=BS1[5]<0..1>                              (Type 6)
    //                      <0>        ：=未被闭锁
    //                      <1>        ：=被闭锁
    //        SB                     ：=BS1[6]<0..1>                              (Type 6)
    //                    <0>        ：=未被取代
    //                    <1>        ：=被取代
    //        NT                     ：=BS1[7]<0..1>                               (Type 6)
    //                    <0>        ：=当前值
    //                    <1>        ：=非当前值
    //        IV                      ：=BS1[8]<0..1>                               (Type 6)
    //                    <0>         ：=有效
    //                    <1>         ：=无效

        int l_i_IV=data_parse%2;  //->8位——右1
        QString l_s_IV;

        if(l_i_IV==0)
            l_s_IV="IV =0  有效 ";
        else
            l_s_IV="IV =1  无效 ";

        //        NT                     ：=BS1[7]<0..1>
        //                      <0>      ：=当前值
        //                      <1>       ：=非当前值
        int l_i_NT=(data_parse>>1)%2; //->7——右2
        QString l_s_NT;

        if(l_i_NT==0)
            l_s_NT="NT=0 当前值 ";
        else
            l_s_NT="NT=1 非当前值 ";

        //        SB                     ：=BS1[6]<0..1>
        //                      <0>      ：=未被取代
        //                      <1>      ：=被取代

        int l_i_SB=(data_parse>>2)%2;//->6——右3
        QString l_s_SB;

        if(l_i_SB==0)
            l_s_SB="SB=0 未被取代 ";
        else
            l_s_SB="SB=1 被取代 ";

        //        BL                     ：=BS1[5]<0..1>
        //                      <0>      ：=未被闭锁
        //                       <1>      ：=被闭锁

        int l_i_BL=(data_parse>>3)%2; //->5——右4
        QString l_s_BL;

        if(l_i_BL==0)
            l_s_BL="SB=0 未被闭锁  ";
        else
            l_s_BL="SB=1 被闭锁  ";

        //        DPI=双点信息           ：=UI2[1..2]<0..3>                           (Type 1.1)
        //                    <0>        ：=不确定或中间状态
        //                    <1>        ：=确定状态开
        //                    <2>        ：=确定状态合
        //                    <3>        ：=不确定或中间状态

        int l_i_DPI=((data_parse>>7)%2)*2+(data_parse>>6)%2;
        QString l_s_DPI;

        switch (l_i_DPI) {
        case 0:
            l_s_DPI="DPI=0 不确定或中间状态 ";
            break;
        case 1:
            l_s_DPI="DPI=1 确定状态开 ";
            break;
        case 2:
            l_s_DPI="DPI=2 确定状态合 ";
            break;
        default:
             l_s_DPI="DPI=3 不确定或中间状态 ";
            break;
        }
        QString l_all="DIQ=CP8{DPI，RES，BL，SB，NT，IV}"+l_s_DPI+l_s_BL+l_s_SB+l_s_NT+l_s_IV;
    //    qDebug()<<l_all;
        return l_all;
}

//********************************************************************************
//函数名：pParseQDS
//功能：解析带品质描述词的单点信息(IEV 371-02-07)(SIQ)
QString informationWord::pParseQDS(int data_parse)
{
    //    QDS              ：=CP8{OV，RES，BL，SB，NT，IV}
    //        OV               ：=BS1[1] <0..1>                                     (Type 6)
    //                  <0>     ：=未溢出
    //                  <1>     ：=溢出
    //        RES=RESERVE     ：=BS3[2..4]<0>                                     (Type 6)
    //        BL                ：=BS1[5]<0..1>                                     (Type 6)
    //                  <0>     ：=未被闭锁
    //                  <1>      ：=被闭锁
    //        SB                ：=BS1[6]<0..1>                                      (Type 6)
    //                  <0>      ：=未被取代
    //                  <1>      ：=被取代
    //        NT                 ：=BS1[7]<0..1>                                     (Type 6)
    //                  <0>       ：=当前值
    //                  <1>       ：=非当前值
    //        IV                  ：=BS1[8]<0..1>                                     (Type 6)
    //                 <0>        ：=有效
    //                 <1>        ：=无效




        int l_i_IV=data_parse%2;
        QString l_s_IV;

        if(l_i_IV==0)
            l_s_IV="IV =0  有效 ";
        else
            l_s_IV="IV =1  无效 ";

        //        NT                     ：=BS1[7]<0..1>
        //                      <0>      ：=当前值
        //                      <1>       ：=非当前值
        int l_i_NT=(data_parse>>1)%2;
        QString l_s_NT;

        if(l_i_NT==0)
            l_s_NT="NT=0 当前值 ";
        else
            l_s_NT="NT=1 非当前值 ";

        //        SB                     ：=BS1[6]<0..1>
        //                      <0>      ：=未被取代
        //                      <1>      ：=被取代

        int l_i_SB=(data_parse>>2)%2;
        QString l_s_SB;

        if(l_i_SB==0)
            l_s_SB="SB=0 未被取代 ";
        else
            l_s_SB="SB=1 被取代 ";

        //        BL                     ：=BS1[5]<0..1>
        //                      <0>      ：=未被闭锁
        //                       <1>      ：=被闭锁

        int l_i_BL=(data_parse>>3)%2;
        QString l_s_BL;

        if(l_i_BL==0)
            l_s_BL="SB=0 未被闭锁  ";
        else
            l_s_BL="SB=1 被闭锁  ";

    //    OV               ：=BS1[1] <0..1>                                     (Type 6)
    //                  <0>     ：=未溢出
    //                  <1>     ：=溢出


        int l_i_OV=(data_parse>>7)%2;
        QString l_s_OV;

        if(l_i_OV==0)
            l_s_OV="OV=0 未溢出  ";
        else
            l_s_OV="OV=1 溢出  ";



        QString l_all="QDS=CP8{OV，RES，BL，SB，NT，IV}"+l_s_OV+l_s_BL+l_s_SB+l_s_NT+l_s_IV;
        //qDebug()<<l_all;
        return l_all;
}

//********************************************************************************
//函数名：pParseQDP
//功能：继电保护设备事件的品质描述词(单个的八位位组 QDP)
QString informationWord::pParseQDP(int data_parse)
{

    //    QDP                    ：=CP8{RES,EI,BL,SB,NT,IV}
    //       RES=RESERVE          ：=BS3[1..3]<0>                              (Type 6)
    //       EI                      ：=BS1[4]<0..1>                              (Type 6)
    //                      <0>       ：=动作时间有效
    //                      <1>       ：=动作时间无效
    //       BL                      ：=BS1[5]<0..1>                              (Type 6)
    //                      <0>       ：=未被闭锁
    //                      <1>       ：=被闭锁
    //       SB                      ：=BS1[6]<0..1>                             (TYPE 6)
    //                     <0>       ：=未被取代
    //                     <1>       ：=被取代
    //       NT                      ：=BS1[7]<0..1>                             (Type 6)
    //                     <0>       ：=当前值
    //                      <1>       ：=非当前值
    //       IV                      ：=BS1[8]<0..1>                              (Type 6)
    //                     <0>       ：=有效
    //                     <1>       ：=无效

        int l_i_IV=data_parse%2;
        QString l_s_IV;

        if(l_i_IV==0)
            l_s_IV="IV =0  有效 ";
        else
            l_s_IV="IV =1  无效 ";

        //        NT                     ：=BS1[7]<0..1>
        //                      <0>      ：=当前值
        //                      <1>       ：=非当前值
        int l_i_NT=(data_parse>>1)%2;
        QString l_s_NT;

        if(l_i_NT==0)
            l_s_NT="NT=0 当前值 ";
        else
            l_s_NT="NT=1 非当前值 ";

        //        SB                     ：=BS1[6]<0..1>
        //                      <0>      ：=未被取代
        //                      <1>      ：=被取代

        int l_i_SB=(data_parse>>2)%2;
        QString l_s_SB;

        if(l_i_SB==0)
            l_s_SB="SB=0 未被取代 ";
        else
            l_s_SB="SB=1 被取代 ";

        //        BL                     ：=BS1[5]<0..1>
        //                      <0>      ：=未被闭锁
        //                       <1>      ：=被闭锁

        int l_i_BL=(data_parse>>3)%2;
        QString l_s_BL;

        if(l_i_BL==0)
            l_s_BL="SB=0 未被闭锁  ";
        else
            l_s_BL="SB=1 被闭锁  ";

        //       EI                      ：=BS1[4]<0..1>                              (Type 6)
        //                      <0>       ：=动作时间有效
        //                      <1>       ：=动作时间无效

        int l_i_EI=(data_parse>>4)%2;
        QString l_s_EI;

        if(l_i_EI==0)
            l_s_EI="EI=0 动作时间有效  ";
        else
            l_s_EI="EI=1 动作时间无效  ";

        QString l_all="QDP=CP8{RES,EI,BL,SB,NT,IV}"+l_s_EI+l_s_BL+l_s_SB+l_s_NT+l_s_IV;
      //  qDebug()<<l_all;
        return l_all;
}

//********************************************************************************
//函数名：pParseVTI
//功能：带瞬变状态指示的值，用于变压器的步位置或者其他步位置信息(VTI)

QString informationWord::pParseVTI(int data_parse)
{
    //    VTI                     ：=CP8{Value,Transient}
    //    Value=值                 ：=I7[1..7]<-64..+63>                         (Type 2.1)
    //    Transient=瞬变状态        ：=BS1[8]<0..1>                             (Type 6)
    //                  <0>	：=设备未在瞬变状态
    //                  <1>        ：=设备处于瞬变状态
    int l_i_BSI=(data_parse>>1)%2;
    QString l_s_BSI;

    if(l_i_BSI==0)
        l_s_BSI="BSI =0  设备未在瞬变状态 ";
    else
        l_s_BSI="BSI=1  设备处于瞬变状态 ";

        //    Value=值                 ：=I7[1..7]<-64..+63>                         (Type 2.1)
    int l_i_panduan=(data_parse>>7)%2;
    int l_i_value=(data_parse>>1)|63;
    QString l_s_value;

    if(l_i_panduan==0)
        l_s_value=tr("value=%1 动作时间有效").arg(l_i_value);
    else if(l_i_value==0)
         l_s_value=tr("value=-64 动作时间有效");
    else {
         l_s_value=tr("value=-%1 动作时间有效").arg(l_i_value);
    }

    QString l_all=" VTI：=CP8{Value,Transient}"+l_s_value+l_i_BSI;
  //  qDebug()<<l_all;
    return l_all;
}


//********************************************************************************
//函数名：pParseNVA
//功能：规一化值
QString informationWord::pParseNVA(int data_parse)
{
    //NVA                     ：=F16[1..16]<-1..+1-2-15>                    (Type 4.1)

    int l_i_panduan=(data_parse>>15)%2;//->判断符号位
    long int l_i_value;
    if(l_i_panduan==1)//->16进制转换成带符号的二进制——在转换成相应的10进制
        l_i_value=data_parse;
    else
        l_i_value=-((data_parse-1)^0xFFFF);


    double l_d_value=l_i_value/65536;//->转换成double型

    QString l_all=tr("NVA：=F16[1..16]<-1..+1-2-15> value：%1").arg(l_d_value);
    qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseSVA——？是否是高位在后？
//功能：标度化值(SVA)
QString informationWord::pParseSVA(int data_parse)
{
    //SVA：=I16[1..16]<- 215..+215-1>
    int l_i_panduan=(data_parse>>15)%2;//->判断符号位
    long int l_i_value;
    if(l_i_panduan==1)//->16进制转换成带符号的二进制——在转换成相应的10进制
        l_i_value=data_parse;
    else
        l_i_value=-((data_parse-1)^0xFFFF);

    QString l_all=tr("SVA：=I16[1..16]<- 215..+215-1> value：%1").arg(l_i_value);
    qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseBCR——？是否是高位在后？
//功能：二进制计数器读数(BCR)
QString informationWord::pParseBCR(long long int data_parse)
{
//    BCR                     ：=CP40{Counter reading,Sequence notation}
//    Counter reading =计数器读数：=I32[1..32]<-231..+231-1>                     (Type 2.1)
//    Sequence notation=顺序记法 ：=CP8{SQ,CY,CA,IV}
//        SQ=顺序号               ：=UI5[33..37]<0..31>                          (Type 1.1)
//        CY=进位                 ：=BS1[38]<0..1>                       (Type 6)
//                      <0>       ：=在相应的累加周期内计数器未溢出
//                      <1>       ：=在相应的累加周期内计数器溢出
//        CA=计数量被调整         ：=BS1[39]<0..1>                       (Type 6)
//                      <0>       ：=上次读数后计数器未被调整
//                      <1>       ：=上次读数后计数器被调整
//        IV=无效                 ：=BS1[40]<0..1>                        (Type 6)
//                      <0>       ：=有效
//                      <1>	：=无效

    int l_i_panduan=(data_parse>>39)%2;
    long int l_i_value=data_parse>>8;
    if(l_i_panduan==1)//->16进制转换成带符号的二进制——在转换成相应的10进制
        l_i_value=data_parse;
    else
        l_i_value=-((data_parse-1)^0xFFFFFFFF);

    QString l_s_value=tr("计数器读数：%1").arg(l_i_value);


    //        IV=无效                 ：=BS1[40]<0..1>                        (Type 6)
    //                      <0>       ：=有效
    //                      <1>	：=无效

    int l_i_IV=data_parse%2;
    QString l_s_IV;

    if(l_i_IV==0)
        l_s_IV="IV =0  有效 ";
    else
        l_s_IV="IV =1  无效 ";

    //        CA=计数量被调整         ：=BS1[39]<0..1>                       (Type 6)
    //                      <0>       ：=上次读数后计数器未被调整
    //                      <1>       ：=上次读数后计数器被调整

    int l_i_CA=(data_parse>>1)%2;
    QString l_s_CA;

    if(l_i_CA==0)
        l_s_CA="CA =0   ：=上次读数后计数器未被调整 ";
    else
        l_s_CA="CA =1  ：=上次读数后计数器被调整 ";

    //        CY=进位                 ：=BS1[38]<0..1>                       (Type 6)
    //                      <0>       ：=在相应的累加周期内计数器未溢出
    //                      <1>       ：=在相应的累加周期内计数器溢出

    int l_i_CY=(data_parse>>2)%2;
    QString l_s_CY;

    if(l_i_CY==0)
        l_s_CY="CY =0   ：=在相应的累加周期内计数器未溢出 ";
    else
        l_s_CY="CY =1  ：=在相应的累加周期内计数器溢出 ";

    //        SQ=顺序号               ：=UI5[33..37]<0..31>                          (Type 1.1)

    int l_i_SQ=(data_parse>>3)|31;
    QString l_s_SQ=tr("SQ=%1").arg(l_i_SQ);

    QString l_all="BCR：=CP40{Counter reading,Sequence notation}  "+l_s_value+l_s_IV+l_s_CA+l_s_CY+l_s_SQ;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseSEPOne
//功能：继电保护设备单个事件(SEP)

QString informationWord::pParseSEPOne(int data_parse)
{
//    SEP                    ：=CP8{ES，RES，EI，BL，SB，NT，IV}
//   ES=事件状态            ：=UI2[1..2] <0..3>                         (Type 1.1)
//                   <0>        ：=不确定或中间状态
//                   <1>        ：=确定状态开
//                   <2>        ：=确定状态合
//                   <3>        ：=不确定或中间状态
//   RES=RESERVE         ：=BS1[3]<0>                                (Type 6)
//       EI                     ：=BS1[4]<0..1>                              (Type 6)
//                     <0>      ：=动作时间有效
//                     <1>      ：=动作时间无效
//       BL                     ：=BS1[5]<0..1>                              (Type 6)
//                     <0>      ：=未被闭锁
//                      <1>      ：=被闭锁
//       SB                     ：=BS1[6]<0..1>                               (Type 6)
//                     <0>      ：=未被取代
//                     <1>      ：=被取代
//       NT                     ：=BS1[7]<0..1>                               (Type 6)
//                     <0>      ：=当前值
//                     <1>       ：=非当前值
//       IV                      ：=BS1[8]<0..1>                               (Type 6)
//                    <0>        ：=有效
//                    <1>        ：=无效

    int l_i_IV=data_parse%2;//->8位是低位
    QString l_s_IV;

    if(l_i_IV==0)
        l_s_IV="IV =0  有效 ";
    else
        l_s_IV="IV =1  无效 ";

    //        NT                     ：=BS1[7]<0..1>
    //                      <0>      ：=当前值
    //                      <1>       ：=非当前值

    int l_i_NT=(data_parse>>1)%2;//->7位是右边第二位
    QString l_s_NT;

    if(l_i_NT==0)
        l_s_NT="NT=0 当前值 ";
    else
        l_s_NT="NT=1 非当前值 ";

    //        SB                     ：=BS1[6]<0..1>
    //                      <0>      ：=未被取代
    //                      <1>      ：=被取代

    int l_i_SB=(data_parse>>2)%2;//->6 位是右边第三位
    QString l_s_SB;

    if(l_i_SB==0)
        l_s_SB="SB=0 未被取代 ";
    else
        l_s_SB="SB=1 被取代 ";

    //        BL                     ：=BS1[5]<0..1>
    //                      <0>      ：=未被闭锁
    //                       <1>      ：=被闭锁

    int l_i_BL=(data_parse>>3)%2;//->5位是右边第四位
    QString l_s_BL;

    if(l_i_BL==0)
        l_s_BL="SB=0 被闭锁  ";
    else
        l_s_BL="SB=1 未被闭锁  ";

    //       EI                      ：=BS1[4]<0..1>                              (Type 6)
    //                      <0>       ：=动作时间有效
    //                      <1>       ：=动作时间无效

    int l_i_EI=(data_parse>>4)%2;
    QString l_s_EI;

    if(l_i_EI==0)
        l_s_EI="EI=0 动作时间有效  ";
    else
        l_s_EI="EI=1 动作时间无效  ";


    //   ES=事件状态            ：=UI2[1..2] <0..3>                         (Type 1.1)
    //                   <0>        ：=不确定或中间状态
    //                   <1>        ：=确定状态开
    //                   <2>        ：=确定状态合
    //                   <3>        ：=不确定或中间状态

    int l_i_ES=((data_parse>>7)%2)*2+(data_parse>>6)%2;
    QString l_s_ES;

    switch (l_i_ES) {
    case 0:
        l_s_ES="ES=0 不确定或中间状态 ";
        break;
    case 1:
        l_s_ES="ES=1 确定状态开 ";
        break;
    case 2:
        l_s_ES="ES=2 确定状态合 ";
        break;
    default:
         l_s_ES="ES=3 不确定或中间状态 ";
        break;
    }


    QString l_all="SEP：=CP8{ES，RES，EI，BL，SB，NT，IV} "+l_s_ES+l_s_EI+l_s_BL+l_s_NT+l_s_IV;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseSEPTwo
//功能：继电保护设备启动事件(SEP)
QString informationWord::pParseSEPTwo(int data_parse)
{
//    SEP                    ：=BS8{GS,SL1,SL2,SL3,SIE,SRD,RES}
//        GS=总启动              ：=BS1[1]<0..1>                              (Type 6)
//                  <0>       ：=无总启动
//                  <1>       ：=总启动
//        SL1=A相保护启动       ：=BS1[2]<0..1>                              (Type 6)
//                  <0>       ：= A相保护未启动
//                  <1>       ：= A相保护启动
//        SL2=B相保护启动        ：=BS1[3]<0..1>                             (Type 6)
//                  <0>       ：= B相保护未启动
//                  <1>       ：= B相保护启动
//        SL3=C相保护启动        ：=BS1[4]<0..1>                             (Type 6)
//                  <0>       ：= C相保护未启动
//                  <1>       ：= C相保护启动
//       SIE=接地电流保护启动     ：=BS1[5]<0..1>                             (Type 6)
//                  <0>       ：=接地电流保护未启动
//                  <1>       ：=接地电流保护启动
//       SRD=反向保护启动        ：=BS1[6]<0..1>                             (Type.6)
//                  <0>       ：=反向保护未启动
//                  <1>       ：=反向保护启动
    int l_i_GS=(data_parse>>7)%2;
    QString l_s_GS;

    if(l_i_GS==0)
        l_s_GS="GS =0  无总启动 ";
    else
        l_s_GS="GS =1  总启动 ";

    //->SL1
    int l_i_SL1=(data_parse>>6)%2;
    QString l_s_SL1;

    if(l_i_SL1==0)
        l_s_SL1="SL1 =0  A相保护未启动 ";
    else
        l_s_SL1="SL1 =1  A相保护启动 ";

    //->SL2
    int l_i_SL2=(data_parse>>5)%2;
    QString l_s_SL2;

    if(l_i_SL2==0)
        l_s_SL2="SL2 =0  B相保护未启动 ";
    else
        l_s_SL2="SL2 =1  B相保护启动 ";

    //->SL3
    int l_i_SL3=(data_parse>>4)%2;
    QString l_s_SL3;

    if(l_i_SL3==0)
        l_s_SL3="SL3 =0  C相保护未启动 ";
    else
        l_s_SL3="SL3 =1  C相保护启动 ";

    //->SIE
    int l_i_SIE=(data_parse>>3)%2;
    QString l_s_SIE;

    if(l_i_SIE==0)
        l_s_SIE="SIE =0  接地电流保护未启动 ";
    else
        l_s_SIE="SIE =1  接地电流保护启动";

    //->SRD
    int l_i_SRD=(data_parse>>2)%2;
    QString l_s_SRD;

    if(l_i_SRD==0)
        l_s_SRD="SRD =0  反向保护未启动 ";
    else
        l_s_SRD="SRD =1  反向保护启动";

    QString l_all="  SEP：=BS8{GS,SL1,SL2,SL3,SIE,SRD,RES} "+l_s_GS+l_s_SL1+l_s_SL2+l_s_SL3+l_s_SIE+l_s_SRD;
  //  qDebug()<<l_all;
    return l_all;

}

//********************************************************************************
//函数名：pParseOCI
//功能：继电保护设备输出电路信息(OCI)
QString informationWord::pParseOCI(int data_parse)
{
//    OCI                          ：=BS8{GC,CL1,CL2,CL3,RES}
//      GC=总命令输出至输出电路      ：=BS1[1]<0..1>                      (Type 6)
//              <0>             ：=无总命令输出至输出电路
//              <1>             ：=总命令输出至输出电路
//      CL1=A相保护命令输出至输出电路：=BS1[2]<0..1>                     (Type 6)
//              <0>             ：=无命令输出至A相输出电路
//              <1>             ：=命令输出至A相输出电路
//      CL2=B相保护命令输出至输出电路：=BS1[3]<0..1>                     (Type 6)
//              <0>             ：= 无命令输出至B相输出电路
//              <1>             ：= 命令输出至B相输出电路
//      CL3=C相保护命令输出至输出电路：=BS1[4]<0..1>                      (Type 6)
//              <0>              ：= 无命令输出至C相输出电路
//              <1>              ：= 命令输出至C相输出电路

    //->GC
    int l_i_GC=(data_parse>>7)%2;
    QString l_s_GC;

    if(l_i_GC==0)
        l_s_GC="GC =0  无总命令输出至输出电路 ";
    else
        l_s_GC="GC =1  总命令输出至输出电路 ";

    //->CL1
    int l_i_CL1=(data_parse>>6)%2;
    QString l_s_CL1;

    if(l_i_CL1==0)
        l_s_CL1="CL1 =0  无命令输出至A相输出电路 ";
    else
        l_s_CL1="CL1 =1  命令输出至A相输出电路";

    //->CL2
    int l_i_CL2=(data_parse>>5)%2;
    QString l_s_CL2;

    if(l_i_CL2==0)
        l_s_CL2="CL2 =0  无命令输出至B相输出电路 ";
    else
        l_s_CL2="CL2=1  命令处处至B相输出电路 ";

    //->CL3
    int l_i_CL3=(data_parse>>4)%2;
    QString l_s_CL3;

    if(l_i_CL3==0)
        l_s_CL3="CL3 =0  无命令输出至C相输出电路 ";
    else
        l_s_CL3="CL3=1  命令处处至C相输出电路 ";

    QString l_all="OCI：=BS8{GC,CL1,CL2,CL3,RES} "+l_s_GC+l_s_CL1+l_s_CL2+l_s_CL3;
  //  qDebug()<<l_all;
    return l_all;
}


//********************************************************************************
//函数名：pParseFBP
//功能：FBP=固定测试字         ：=UI16[1..16]<55AA>
QString informationWord::pParseFBP()
{
    return "FBP=固定测试字";
}

//********************************************************************************
//函数名：pParseSCO
//功能：单命令
QString informationWord::pParseSCO(int data_parse)
{
//    单命令[IEV-371-03-02] (SCO)
//    SCO=单命令             ：=CP8[SCS,BS1,QOC]
//        SCS=单命令状态         ：=BS1[1]<0..1>                            (Type 6)
//                    <0>        ：=开
//                    <1>        ：=合
//    QOC=                  ：=CP6[3..8]{QU,S/E}
//    QOC                 ：＝CP6{QU,S/E}
//    QU                   ：＝UI5[3..7]<0..31>                                  (Type 1.1)
//                  <0>        ：=无另外的定义2)
//                  <1>        ：＝短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定
//                  <2>         ：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定
//              <3>        ：＝持续输出
//                 <4..8>       ：=为本配套标准的标准定义保留(兼容范围)
//                <9..15>       ：=为其他预先定义的功能选集保留3)
//               <16..31>       ：=为特定使用保留(专用范围)
//    S/E=                  ：=BS1[8]<0..1>                                  (Type 6)
//                  <0>         ：=执行
//                  <1>          ：＝选择


    //->SCS
    int l_i_SCS=(data_parse>>7)%2;
    QString l_s_SCS;

    if(l_i_SCS==0)
        l_s_SCS="SCS =0  开 ";
    else
        l_s_SCS="SCS=1  合 ";

    //->QU
    int l_i_QU=(data_parse>>1)|31;
    QString l_s_QU;

    switch (l_i_QU) {
    case 0:
        l_s_QU="QU=0:无另外的定义2";
        break;
    case 1:
        l_s_QU="QU=1  :短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定";
        break;
    case 2:
        l_s_QU=" QU=2：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定";
        break;
    case 3:
        l_s_QU="QU=3 :持续输出";
        break;
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
        l_s_QU="QU=<4..8>：=为本配套标准的标准定义保留(兼容范围)";
                break;
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
        l_s_QU="QU=<9..15>：=为其他预先定义的功能选集保留3";
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
        l_s_QU="QU=<16..31>       ：=为特定使用保留(专用范围)";
    default:
        break;
    }

     //->s/e
    int l_i_BSI=data_parse%2;
    QString l_s_BSI;

    if(l_i_BSI==0)
        l_s_BSI="BSI =0  执行 ";
    else
        l_s_BSI="BSI =1  选择 ";

    QString l_all=" SCO=单命令：=CP8[SCS,BS1,QOC]"+l_s_SCS+l_s_QU+l_s_BSI;
  //  qDebug()<<l_all;
    return l_all;
}


//********************************************************************************
//函数名：pParseDCO
//功能：双命令
QString informationWord::pParseDCO(int data_parse)
{
//    DCO=双命令             ：=CP8[DCS,QOC]
//    DCS=双命令状态         ：=UI2[1..2]<0..3>                            (Type 1.1)
//                <0>         ：=不允许
//                    <1>         ：=开
//                     <2>         ：=合
//                    <3>         ：=不允许
//    QOC=                    ：=CP6[3..8]{QU,S/E}                        见7.2.6.26QOC

    int l_i_DCS=((data_parse>>7)%2)*2+(data_parse>>6)%2;
    QString l_s_DCS;

    //DCS
    switch (l_i_DCS) {
    case 0:
        l_s_DCS="DCS=0 不允许  ";
        break;
    case 1:
        l_s_DCS="DCS=1 开";
        break;
    case 2:
        l_s_DCS="DCS=2 合 ";
        break;
    default:
         l_s_DCS="DCS=3 不允许 ";
        break;
    }

    //->QU
    int l_i_QU=(data_parse>>1)|31;
    QString l_s_QU;

    switch (l_i_QU) {
    case 0:
        l_s_QU="QU=0:无另外的定义2";
        break;
    case 1:
        l_s_QU="QU=1  :短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定";
        break;
    case 2:
        l_s_QU=" QU=2：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定";
        break;
    case 3:
        l_s_QU="QU=3 :持续输出";
        break;
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
        l_s_QU="QU=<4..8>：=为本配套标准的标准定义保留(兼容范围)";
                break;
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
        l_s_QU="QU=<9..15>：=为其他预先定义的功能选集保留3";
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
        l_s_QU="QU=<16..31>       ：=为特定使用保留(专用范围)";
    default:
        break;
    }


    //->s/e
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="s/E =0  执行 ";
   else
       l_s_BSI="S/E =1  选择 ";


    QString l_all=" DCO=双命令：=CP8[DCS,QOC]"+l_s_DCS+l_s_QU+l_s_BSI;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseDCO
//功能：双命令
QString informationWord::pParseRCO(int data_parse)
{
//    RCO=步调节命令             ：=CP8[RCS,QOC]
//    RCS=步调节命令状态         ：=UI2[1..2]<0..3>                       (Type 1.1)
//                <0>         ：=不允许
//                    <1>         ：=降一步
//                    <2>         ：=升一步
//                     <3>         ：=不允许
//    QOC=                    ：=CP6[3..8]{QU,S/E}                        见7.2.6.26QOC

    int l_i_RCS=((data_parse>>6)%2)*2+(data_parse>>5)%2;
    QString l_s_RCS;

    //DCS
    switch (l_i_RCS) {
    case 0:
        l_s_RCS="RCS=0 不允许  ";
        break;
    case 1:
        l_s_RCS="RCS=1 降一步";
        break;
    case 2:
        l_s_RCS="RCS=2 升一步 ";
        break;
    default:
         l_s_RCS="RCS=3 不允许 ";
        break;
    }

    //->QU
    int l_i_QU=(data_parse>>1)|31;
    QString l_s_QU;

    switch (l_i_QU) {
    case 0:
        l_s_QU="QU=0:无另外的定义2";
        break;
    case 1:
        l_s_QU="QU=1  :短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定";
        break;
    case 2:
        l_s_QU=" QU=2：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定";
        break;
    case 3:
        l_s_QU="QU=3 :持续输出";
        break;
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
        l_s_QU="QU=<4..8>：=为本配套标准的标准定义保留(兼容范围)";
                break;
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
        l_s_QU="QU=<9..15>：=为其他预先定义的功能选集保留3";
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
        l_s_QU="QU=<16..31>       ：=为特定使用保留(专用范围)";
    default:
        break;
    }


    //->s/e
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="s/E =0  执行 ";
   else
       l_s_BSI="S/E =1  选择 ";


    QString l_all=" DCO=双命令：=CP8[DCS,QOC]"+l_s_RCS+l_s_QU+l_s_BSI;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseCOI
//功能：初始化原因
QString informationWord::pParseCOI(int data_parse)
{
//    COI                     ：=CP8{UI7[1..7],BS1[8]}                      (Type 1.1)
//    UI7[1..7]<0..127>
//                    <0>         ：=当地电源合上
//                     <1>         ：=当地手动复位
//                    <2>         ：=远方复位
//                 <3..31>         ：=为本配套标准的标准定义保留(兼容范围)
//                <32..127>        ：=为特定使用保留(专用范围)
//    BS1[8]<0..1>                                                          (Type 6)
//                   <0>          ：=未改变当地参数的初始化
//                   <1>          ：=改变当地参数后的初始化

    //->QU
    int l_i_UI7=data_parse>>1;
    QString l_s_UI7;

    switch (l_i_UI7) {
    case 0:
        l_s_UI7="UI7=0：当地电源合上";
        break;
    case 1:
        l_s_UI7="UI7=1  :当地手动复位";
        break;
    case 2:
        l_s_UI7="UI7=2：远方复位";
        break;
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
        l_s_UI7="UI7<3..31> ：为本配套标准的标准定义保留(兼容范围)";
    default:
        l_s_UI7=" UI7<32..127>        ：=为特定使用保留(专用范围)";
        break;
    }
    //->BS1
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="BSI =0  ：=未改变当地参数的初始化 ";
   else
       l_s_BSI="BSI =1  ：=改变当地参数后的初始化 ";

   QString l_all="  COI ：=CP8{UI7[1..7],BS1[8]}      "+l_s_UI7+l_s_BSI;
 //  qDebug()<<l_all;
   return l_all;
}

//********************************************************************************
//函数名：pParseQOI
//功能：召唤限定词(QOI)
QString informationWord::pParseQOI(int data_parse)
{
//    QOI                    ：=UI[1..8\<0..255>
//                  <0>          ：=未用
//               <1..19>          ：=为本配套标准的标准定义保留(兼容范围)
//                 <20>          ：＝站召唤(全局)
//                 <21>          ：＝第1组召唤
//                 <22>          ：＝第2组召唤
//                 <23>          ：＝第3组召唤
//                 <24>          ：＝第4组召唤
//                 <25>          ：＝第5组召唤
//                 <26>          ：＝第6组召唤
//                 <27>          ：＝第7组召唤
//                 <28>          ：＝第8组召唤
//                 <29>          ：＝第9组召唤
//                 <30>          ：＝第10组召唤
//                 <31>          ：＝第11组召唤
//                 <32>          ：＝第12组召唤
//                 <33>          ：＝第13组召唤
//                 <34>          ：＝第14组召唤
//                 <35>          ：＝第15组召唤
//                 <36>          ：＝第16组召唤
//                <32..63>        ：=为配套标准的标准定义保留(兼容范围)
//                <64..255>       ：=为特定使用保留(专用范围)

    //->QOI
    int l_i_QOI=data_parse;
    QString l_s_QOI;

    if(l_i_QOI==0){
        l_s_QOI="QOI=0 未用";
    }else if(l_i_QOI<=19&&l_i_QOI>0)
    {
        l_s_QOI="QOI=<1...19> ：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_QOI==20)
    {
         l_s_QOI="QOI=20：站召唤（全局）";
    }else if(l_i_QOI==21)
    {
         l_s_QOI="QOI=21：第1组召唤";
    }else if(l_i_QOI==22)
    {
        l_s_QOI="QOI=22：第2组召唤";
    }else if(l_i_QOI==23)
    {
        l_s_QOI="QOI=23：第3组召唤";
    }else if(l_i_QOI==24)
    {
        l_s_QOI="QOI=24：第4组召唤";
    }else if(l_i_QOI==25)
    {
        l_s_QOI="QOI=25：第5组召唤";
    }else if(l_i_QOI==26)
    {
        l_s_QOI="QOI=26：第6组召唤";
    }else if(l_i_QOI==27)
    {
        l_s_QOI="QOI=27：第7组召唤";
    }else if(l_i_QOI==28)
    {
        l_s_QOI="QOI=28：第8组召唤";
    }else if(l_i_QOI==29)
    {
        l_s_QOI="QOI=29：第9组召唤";
    }else if(l_i_QOI==30)
    {
        l_s_QOI="QOI=30：第10组召唤";
    }else if(l_i_QOI==31)
    {
        l_s_QOI="QOI=31：第11组召唤";
    }else if(l_i_QOI==32)
    {
        l_s_QOI="QOI=32：第12组召唤";
    }else if(l_i_QOI==33)
    {
        l_s_QOI="QOI=33：第13组召唤";
    }else if(l_i_QOI==34)
    {
        l_s_QOI="QOI=34：第14组召唤";
    }else if(l_i_QOI==35)
    {
        l_s_QOI="QOI=35：第15组召唤";
    }else if(l_i_QOI==36)
    {
        l_s_QOI="QOI=36：第16组召唤";
    }else if(l_i_QOI<=63&&l_i_QOI>36)
    {
        l_s_QOI="QOI<32..63>：=为配套标准的标准定义保留(兼容范围)";
    }else
    {
        l_s_QOI="QOI=<64..255>：=为特定使用保留(专用范围)";
    }
    return l_s_QOI;
}

//********************************************************************************
//函数名：pParseQCC
//功能：计数量召唤命令限定词(QCC)
QString informationWord::pParseQCC(int data_parse)
{
//    QCC                     ：=CP8{RQT,FRZ}
//        RQT=请求                ：=UI6[1..6]<0..63>                               (Type 1.1)
//                  <0>            ：=没请求计数量（未采用）
//                  <1>            ：＝请求计数量第1组
//                  <2>            ：＝请求计数量第2组
//              <3>            ：＝请求计数量第3组
//                  <4>            ：＝请求计数量第4组
//                  <5>            ：＝总的请求计数量
//                 <6..31>          ：=为本配套标准的标准定义保留(兼容范围)
//                <32..63>          ：= 为特定使用保留(专用范围)
//       FRZ=冻结                 ：=UI2[7..8]<0..63>                                 (Type 1.1)
//                  <0>            ：=读(无冻结或复位）
//                  <1>            ：＝计数量冻结不带复位（被冻结的值为累计量）
//                  <2>            ：＝计数量冻结带复位（被冻结的值为增量信息）
//              <3>            ：＝计数量复位
    int l_i_RQT=data_parse>>2;
    QString l_s_RQT;

    if(l_i_RQT==0){
        l_s_RQT="RQT=0  没请求计数量（未采用）";
    }else if(l_i_RQT==1)
    {
        l_s_RQT="RQT=1 请求计数量第1组";
    }else if(l_i_RQT==2)
    {
        l_s_RQT="RQT=2 请求计数量第2组";
    }else if(l_i_RQT==3)
    {
        l_s_RQT="RQT=3 请求计数量第3组";
    }else if(l_i_RQT==4)
    {
        l_s_RQT="RQT=4 请求计数量第3组";
    }else if(l_i_RQT==5)
    {
        l_s_RQT="RQT=5 总的请求计数量";
    }else if(l_i_RQT>=6&&l_i_RQT<=31)
    {
        l_s_RQT="RQT=<6..31>：=为本配套标准的标准定义保留(兼容范围)";
    }else
    {
        l_s_RQT="RQT=<32..63>：= 为特定使用保留(专用范围)";
    }


    //->冻结
    int l_i_FRZ=((data_parse>>1)%2)*2+(data_parse>>5)%2;
    QString l_s_FRZ;
    //DCS
    switch (l_i_FRZ) {
    case 0:
        l_s_FRZ="FRZ=0 =读(无冻结或复位）";
        break;
    case 1:
        l_s_FRZ="FRZ=1 ＝计数量冻结不带复位（被冻结的值为累计量）";
        break;
    case 2:
        l_s_FRZ="FRZ=2 ＝计数量冻结带复位（被冻结的值为增量信息） ";
        break;
    default:
         l_s_FRZ="FRZ=3 ＝计数量复位 ";
        break;
    }

    QString l_all=" QCC ：=CP8{RQT,FRZ}"+l_s_RQT+l_s_FRZ;
  //  qDebug()<<l_all;
    return l_all;
}


//********************************************************************************
//函数名：pParseQPM
//功能：计数量召唤命令限定词(QCC)
QString informationWord::pParseQPM(int data_parse)
{
//    QPM                     ：＝CP8{KPA,LPC,POP}
//    KPA=参数类别            ：＝UI6[1..6]<0..63>                              (Type 1.1)
//                  <0>            ：=未用
//                  <1>            ：＝门限值
//                  <2>            ：＝平滑系数(滤波时间常数)
//                  <3>            ：＝传送测量值的下限
//                  <4>            ：＝传送测量值的上限
//                 <5..31>          ：=为本配套标准的标准定义保留(兼容范围)
//                <32..63>          ：= 为特定使用保留(专用范围)
//    LPC= 当地参数改变        ：=BS1[7]<0..1>                                  (Type 6)
//                  <0>            ：=未改变
//                  <1>            ：＝改变
//    POP= 参数在运行          ：=BS1[8]<0..1>                                  (Type 6)
//                  <0>            ：=运行
//                  <1>            ：＝未运行

    //->KPA
    int l_i_KPA=data_parse>>2;
    QString l_s_KPA;

    if(l_i_KPA==0){
        l_s_KPA="KPA=0  未用";
    }else if(l_i_KPA==1)
    {
        l_s_KPA="KPA=1 门限值";
    }else if(l_i_KPA==2)
    {
        l_s_KPA="KPA=2 平滑系数(滤波时间常数)";
    }else if(l_i_KPA==3)
    {
        l_s_KPA="KPA=3 传送测量值的下限";
    }else if(l_i_KPA==4)
    {
        l_s_KPA="KPA=4 传送测量值的上限";
    }else if(l_i_KPA>=5&&l_i_KPA<=31)
    {
        l_s_KPA="KPA=<6..31>：=为本配套标准的标准定义保留(兼容范围)";
    }else
    {
        l_s_KPA="RQT=<32..63>：= 为特定使用保留(专用范围)";
    }

    //->LPC
   int l_i_LPC=(data_parse>>1)%2;
   QString l_s_LPC;

   if(l_i_LPC==0)
       l_s_LPC="LPC =0  ：未改变 ";
   else
       l_s_LPC="LPC =1  ：改变 ";

   //->POP
  int l_i_POP=data_parse%2;
  QString l_s_POP;

  if(l_i_POP==0)
      l_s_POP="POP =0  ：未改变 ";
  else
      l_s_POP="POP=1  ：改变 ";

  QString l_all="  QPM：＝CP8{KPA,LPC,POP}"+l_s_KPA+l_s_LPC+l_s_POP;
//  qDebug()<<l_all;
  return l_all;
}

//********************************************************************************
//函数名：pParseQPA
//功能：参数激活限定词
QString informationWord::pParseQPA(int data_parse)
{
//    QPA                      ：＝UI8[1..8]<0..255>                              (Type 1.1)
//                  <0>            ：=未用
//                  <1>            ：＝激活/仃止激活这之前装载的参数(信息对象地址=0)1)
//                  <2>            ：＝激活/仃止激活所寻址信息对象的参数1)
//                  <3>            ：＝激活/仃止激活所寻址的持续循环或周期传输的信息对象
//                  <4..127>          ：=为本配套标准的标准定义保留(兼容范围)
//                  <128..255>          ：= 为特定使用保留(专用范围)
    int l_i_QPA=data_parse;
    QString l_s_QPA;

    if(l_i_QPA==0){
        l_s_QPA="QPA=0  未用";
    }else if(l_i_QPA==1)
    {
        l_s_QPA="QPA=1 ＝激活/仃止激活这之前装载的参数(信息对象地址=0)1)";
    }else if(l_i_QPA==2)
    {
        l_s_QPA="QPA=2 激活/仃止激活所寻址信息对象的参数1)";
    }else if(l_i_QPA==3)
    {
        l_s_QPA="QPA=3 ＝激活/仃止激活所寻址的持续循环或周期传输的信息对象";
    }else if(l_i_QPA>=4&&l_i_QPA<=127)
    {
        l_s_QPA="QPA=<6..31>：=为本配套标准的标准定义保留(兼容范围)";
    }else
    {
        l_s_QPA="QPA=<128..255>：= 为特定使用保留(专用范围)";
    }

    QString l_all=" QPA ：＝UI8[1..8]<0..255>  "+l_s_QPA;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseQOC
//功能：命令限定词(QOC)
QString informationWord::pParseQOC(int data_parse)
{
//    QOC                 ：＝CP6{QU,S/E}
//    QU                   ：＝UI5[3..7]<0..31>                                  (Type 1.1)
//                  <0>        ：=无另外的定义2)
//                  <1>        ：＝短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定
//                  <2>         ：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定
//                  <3>        ：＝持续输出
//                 <4..8>       ：=为本配套标准的标准定义保留(兼容范围)
//                <9..15>       ：=为其他预先定义的功能选集保留3)
//               <16..31>       ：=为特定使用保留(专用范围)
//    S/E=                  ：=BS1[8]<0..1>                                  (Type 6)
//                  <0>         ：=执行
//                  <1>          ：＝选择

    int l_i_UC=(data_parse>>1)|31;
    QString l_s_UC;

    if(l_i_UC==0){
        l_s_UC="UC=0：=无另外的定义2)";
    }else if(l_i_UC==1)
    {
        l_s_UC="UC=1：＝短脉冲持续时间(断路器)，持续时间由被控站内的系统参数所确定   ";
    }else if(l_i_UC==2)
    {
        l_s_UC="UC=2 ：＝长脉冲持续时间，持续时间由被控站内的系统参数所确定";
    }else if(l_i_UC==3)
    {
        l_s_UC="UC=3 持续输出";
    }else if(l_i_UC>=4&&l_i_UC<=8)
    {
        l_s_UC="UC=<4..8>：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_UC>=9&&l_i_UC<=15)
    {
        l_s_UC="  UC=<9..15> ：=为其他预先定义的功能选集保留3)";
    }else if(l_i_UC>=15&&l_i_UC<=31)
    {
        l_s_UC="UC=<15..31>：=为特定使用保留(专用范围)";
    }


    //->s/e
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="BSI =0  执行 ";
   else
       l_s_BSI="BSI =1  选择 ";

   QString l_all="  QOC：＝CP6{QU,S/E}"+l_s_UC+l_s_BSI;
 //  qDebug()<<l_all;
   return l_all;
}

//********************************************************************************
//函数名：pParseQRP
//功能：复位进程命令限定词
QString informationWord::pParseQRP(int data_parse)
{
//    QRP                      ：＝UI8[2..7]<0..255》                          (Type 1.1)
//                      <0>        ：=未采用
//                      <1>        ：＝进程的总复位
//                      <2>        ：＝复位事件缓冲区等待处理的带时标的信息
//                      <3..127>        ：=为本配套标准的标准定义保留(兼容范围)
//                      <128..255>        ：= 为特定使用保留(专用范围)
    int l_i_ORP=(data_parse>>1)|63;
    QString l_s_ORP;

    if(l_i_ORP==0){
        l_s_ORP="ORP=0：未采用)";
    }else if(l_i_ORP==1)
    {
        l_s_ORP="ORP=1 进程总复位  ";
    }else if(l_i_ORP==2)
    {
        l_s_ORP="ORP=2 ：复位事件缓冲区等待处理的带时标的信息";
    }else if(l_i_ORP>=3&&l_i_ORP<=127)
    {
        l_s_ORP="ORP=<3..127>        ：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_ORP>=128&&l_i_ORP<=255)
    {
        l_s_ORP=" ORP=<128..255>：= 为特定使用保留(专用范围)";
    }

    QString l_all="  QRP ：＝UI8[2..7]<0..255》 "+l_s_ORP;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseFRQ
//功能：pParseFRQ
QString informationWord::pParseFRQ(int data_parse)
{
//    FRQ                       ：＝CP8{UI7[1..7],BS1[8]}
//   UI7[1..7]<0..127>                                                        (Type 1.1)
//                    <0>          ：=缺省
//                    <1..63>          ：=为本配套标准的标准定义保留(兼容范围)
//                    <64..127>          ：=为特定使用保留(专用范围)
//       BS1[8]<0..1>                                                             (Type 6)
//                  <0>             ：=选择、请求、仃止激活、或删除的肯定确认
//                  <1>             ：＝选择、请求、仃止激活、或删除的否定确认


    int l_i_UI7=(data_parse>>1)|127;
    QString l_s_UI7;

    if(l_i_UI7==0){
        l_s_UI7="UC=0：缺省";
    }else if(l_i_UI7>=1&&l_i_UI7<=63)
    {
        l_s_UI7="UI7=<1..63>：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_UI7>=64&&l_i_UI7<=127)
    {
        l_s_UI7="UI7=<64..127> ：=为特定使用保留(专用范围)";
    }

    //->BS1
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="BSI =0  选择、请求、仃止激活、或删除的肯定确认 ";
   else
       l_s_BSI="BSI =1  选择、请求、仃止激活、或删除的否定确认 ";

   QString l_all="   FRQ ：＝CP8{UI7[1..7],BS1[8]}   "+l_s_UI7+l_s_BSI;
 //  qDebug()<<l_all;
   return l_all;

}

//********************************************************************************
//函数名：pParseSRQ
//功能：节准备就绪限定词(SRQ)
QString informationWord::pParseSRQ(int data_parse)
{
//    SRQ                       ：＝CP8{UI7[1..7],BS1[8]}
//    UI7[1..7]<0..127>                                                        (Type 1.1)
//                     <0>          ：=缺省
//                  <1..63>          ：=为本配套标准的标准定义保留(兼容范围)
//                <64..127>          ：=为特定使用保留(专用范围)
//        BS1[8]<0..1>                                                             (Type 6)
//                  <0>             ：=节准备就绪
//                   <1>             ：＝节未准备就绪


    int l_i_UI7=data_parse>>1;
    QString l_s_UI7;

    if(l_i_UI7==0){
        l_s_UI7="UC=0：缺省";
    }else if(l_i_UI7>=1&&l_i_UI7<=63)
    {
        l_s_UI7="UI7=<1..63>：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_UI7>=64&&l_i_UI7<=127)
    {
        l_s_UI7="UI7=<64..127> ：=为特定使用保留(专用范围)";
    }

    //->BS1
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="BSI =0  节准备就绪 ";
   else
       l_s_BSI="BSI =1  节未准备就绪 ";

   QString l_all="   FRQ ：＝CP8{UI7[1..7],BS1[8]}   "+l_s_UI7+l_s_BSI;
 //  qDebug()<<l_all;
   return l_all;
}

//********************************************************************************
//函数名：pParseSCQ
//功能：选择和召唤限定词(SCQ)
QString informationWord::pParseSCQ(int data_parse)
{
//    SCQ                       ：＝CP8{UI7[1..4],UI4[5..8]}
//    UI4[1..4]<<0..15>                                                         (Type 1.1)
//                     <0>          ：=缺省
//                     <1>          ：=选择文件
//                     <2>          ：=请求文件
//                     <3>          ：=仃止激活文件
//                     <4>          ：=删除文件
//                     <5>          ：=选择节
//                     <6>          ：=请求节
//                     <7>          ：=仃止激活节
//                  <8..10>          ：=为本配套标准的标准定义保留(兼容范围)
//                 <11..15>          ：=为特定使用保留(专用范围)
//      UI4[5..8]<0..15>                                                        (Type 1.1)
//                     <0>          ：=缺省
//                     <1>          ：=无所请求的存储空间
//                     <2>          ：=校验和错
//                     <3>          ：=非所期望的通信服务
//                     <4>          ：=非所期望的文件名称
//                     <5>          ：=非所期望的节名称
//                  <6..10>          ：=为本配套标准的标准定义保留(兼容范围)
//                 <11..15>          ：=为特定使用保留(专用范围)

    //->UI4
    int l_i_UI4=data_parse>>4;
    QString l_s_UI4;
    //UI4
    switch (l_i_UI4) {
    case 0:
        l_s_UI4="UI4=0  缺省";
        break;
    case 1:
        l_s_UI4="UI4=1 选择文件";
        break;
    case 2:
        l_s_UI4="UI4=2 请求文件 ";
        break;
    case 3:
        l_s_UI4="UI4=3 停止激活文件";
        break;
    case 4:
        l_s_UI4="UI4=4 删除文件";
        break;
    case 5:
        l_s_UI4="UI4=5 选择节";
        break;
    case 6:
        l_s_UI4="UI4=6 请求节";
        break;
    case 7:
        l_s_UI4="UI4=7 停止激活";
        break;
    case 8:
    case 9:
    case 10:
        l_s_UI4="UI4=8 9 10为本配套标准的标准定义保留(兼容范围) ";
        break;
    default:
         l_s_UI4="UI4=<11..15>：=为特定使用保留(专用范围)";
        break;
    }

    //->
    int l_i_UI42=data_parse|15;
    QString l_s_UI42;
    //UI4
    switch (l_i_UI42) {
    case 0:
        l_s_UI42="UI4=0  缺省";
        break;
    case 1:
        l_s_UI42="UI4=1 无所请求的存储空间";
        break;
    case 2:
        l_s_UI42="UI4=2 校验和错 ";
        break;
    case 3:
        l_s_UI42="UI4=3 非所期望的通信服务";
        break;
    case 4:
        l_s_UI42="UI4=4 非所期望的文件名称";
        break;
    case 5:
        l_s_UI42="UI4=5 非所期望的节名称";
        break;
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        l_s_UI42="UI4=6 7 8 9 10为本配套标准的标准定义保留(兼容范围) ";
        break;
    default:
         l_s_UI4="UI4=<11..15>：=为特定使用保留(专用范围)";
        break;
    }

    QString l_all=" SCQ  ：＝CP8{UI7[1..4],UI4[5..8]} "+l_s_UI4+l_s_UI42;
  //  qDebug()<<l_all;
    return l_all;

}

//********************************************************************************
//函数名：pParseLSQ
//功能：最后的节和段的限定词(LSQ)
QString informationWord::pParseLSQ(int data_parse)
{
//    LSQ                      ：＝UI8[1..8]<0..255>                              (Type 1.1)
//                 <0>            ：=未用
//                 <1>            ：＝不带仃止激活的文件传输
//                 <2>            ：＝带仃止激活的文件传输
//                 <3>            ：＝不带仃止激活的节传输
//                 <4>            ：＝带仃止激活的节传输
//               <5..127>          ：=为本配套标准的标准定义保留(兼容范围)
//             <128..255>          ：= 为特定使用保留(专用范围)

    int l_i_LSQ=data_parse;
    QString l_s_LSQ;

    if(l_i_LSQ==0){
        l_s_LSQ="LSQ=0  未用";
    }else if(l_i_LSQ==1)
    {
        l_s_LSQ="LSQ=1 不带仃止激活的文件传输";
    }else if(l_i_LSQ==2)
    {
        l_s_LSQ="LSQ=2 带仃止激活的文件传输";
    }else if(l_i_LSQ==3)
    {
        l_s_LSQ="LSQ=3 不带仃止激活的节传输";
    }else if(l_i_LSQ==4)
    {
        l_s_LSQ="LSQ=4 带仃止激活的节传输";
    }
    else if(l_i_LSQ>=5&&l_i_LSQ<=127)
    {
        l_s_LSQ="LSQ=<5..127>：=为本配套标准的标准定义保留(兼容范围)";
    }else
    {
        l_s_LSQ="LSQ=<128..255>：= 为特定使用保留(专用范围)";
    }

    QString l_all=" QPA ：＝UI8[1..8]<0..255>  "+l_s_LSQ;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseAFQ
//功能：文件认可或节认可限定词(AFQ)
QString informationWord::pParseAFQ(int data_parse)
{
//    AFQ                      ：=CP{UI4[1..4],UI4[5..8]}
//       UI4[1..4]<0..15>                                                             (Type 1.1)
//                 <0>            ：=未用
//                 <1>            ：＝文件传输的肯定认可
//                 <2>            ：＝文件传输的否定认可
//                 <3>            ：＝节传输的肯定认可
//                 <4>            ：＝节传输的否定认可
//              <5..10>            ：=为本配套标准的标准定义保留(兼容范围)
//             <11..15>            ：= 为特定使用保留(专用范围)
//       UI4[5..8]<0..15>                                                             (Type 1.1)
//                 <0>            ：=缺省
//                 <1>            ：=无所请求的存储空间
//                 <2>            ：=校验和错
//                 <3>            ：=非所期望的通信服务
//                 <4>            ：=非所期望的文件名称
//                 <5>            ：=非所期望的节名称
//              <6..10>            ：=为本配套标准的标准定义保留(兼容范围)
//              <11..15>           ：=为特定使用保留(专用范围)

    //->UI4
    int l_i_UI4=data_parse>>4;
    QString l_s_UI4;
    //UI4
    switch (l_i_UI4) {
    case 0:
        l_s_UI4="UI4=0  缺省";
        break;
    case 1:
        l_s_UI4="UI4=1 文件传输的肯定认可";
        break;
    case 2:
        l_s_UI4="UI4=2 文件传输的否定认可 ";
        break;
    case 3:
        l_s_UI4="UI4=3 节传输的否定认可";
        break;
    case 4:
        l_s_UI4="UI4=4 节传输的否定认可";
        break;
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        l_s_UI4="UI4=8 9 10为本配套标准的标准定义保留(兼容范围) ";
        break;
    default:
         l_s_UI4="UI4=<11..15>：=为特定使用保留(专用范围)";
        break;
    }

    //->
    int l_i_UI42=data_parse|15;
    QString l_s_UI42;
    //UI4
    switch (l_i_UI42) {
    case 0:
        l_s_UI42="UI4=0  缺省";
        break;
    case 1:
        l_s_UI42="UI4=1 无所请求的存储空间";
        break;
    case 2:
        l_s_UI42="UI4=2 校验和错 ";
        break;
    case 3:
        l_s_UI42="UI4=3 非所期望的通信服务";
        break;
    case 4:
        l_s_UI42="UI4=4 非所期望的文件名称";
        break;
    case 5:
        l_s_UI42="UI4=5 非所期望的节名称";
        break;
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        l_s_UI42="UI4=6 7 8 9 10为本配套标准的标准定义保留(兼容范围) ";
        break;
    default:
         l_s_UI4="UI4=<11..15>：=为特定使用保留(专用范围)";
        break;
    }

    QString l_all=" SCQ  ：＝CP8{UI7[1..4],UI4[5..8]} "+l_s_UI4+l_s_UI42;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseNOF
//功能：文件名
QString informationWord::pParseNOF(int data_parse)
{
//    NOF                      ：＝UI16[1..16]<0..65535>              (Type 1.1)
//                  <0>            ：=缺省
//            <1.. 65535>          ：＝文件名称
    int l_i_NOF=data_parse;
    if(l_i_NOF)
        return "缺省";
    else {
        return tr("文件名：%1").arg(l_i_NOF);
    }
}

//********************************************************************************
//函数名：pParseNOS
//功能：节名称
QString informationWord::pParseNOS(int data_parse)
{
//    NOS                       ：＝UI8[1..8]<0..255>                  (Type 1.1)
//                  <0>            ：=缺省
//              <1.. 255>           ：＝节名称
    int l_i_NOS=data_parse;
    if(l_i_NOS)
        return "缺省";
    else {
        return tr("节名称：%1").arg(l_i_NOS);
    }
}

//********************************************************************************
//函数名：pParseLOF
//功能：文件或节的长度(LOF)
QString informationWord::pParseLOF(int data_parse)
{
//    LOF                       ：＝UI24[1..24]<0..16777215>            (Type 1.1)
//                  <0>            ：=未用
//         <1.. 16777215>          ：＝整个文件或节的八位位组数
   long   int l_i_LOF=data_parse;
    if(l_i_LOF)
        return "缺省";
    else {
        return tr("整个文件或节的八位位组数：%1").arg(l_i_LOF);
    }
}

//********************************************************************************
//函数名：pParseLOS
//功能：段的长度(LOS)
QString informationWord::pParseLOS(int data_parse)
{
//    LOS                      ：＝UI8[1..8]<0..255>                     (TYPE 1.1)
//                <0>            ：=未用
//             <1.. n>           ：＝段的八位位组数
     int l_i_LOS=data_parse;
     if(l_i_LOS)
         return "缺省";
     else {
         return tr("段的八位位组数：%1").arg(l_i_LOS);
     }

}

//********************************************************************************
//函数名：pParseCHS
//功能：校验和(CHS)
QString informationWord::pParseCHS(int data_parse)
{
//    CHS                      ：＝UI8[1..8]<0..255>                     (Type 1.1)
//           <0.. 255>         ：＝对一个节的全部八位位组(当用于最后段规约数据单元中)或者整
//                                   个文件的全部八位位组(当用于最后节规约数据单元中)不考虑溢
//                                    出的算术和(256模加)
    return  tr("对一个节的全部八位位组(当用于最后段规约数据单元中)或者整个文件的全部八位位组(当用于最后节规约数据单元中) 出的算术和(256模加)：%1")
            .arg(data_parse);

}

//********************************************************************************
//函数名：pParseSOF
//功能：文件的状态(SOF)
QString informationWord::pParseSOF(int data_parse)
{
//    SOF                    ：＝CP8{STATUS,LFD,FOR,FA}
//    STATUS                 ：＝UI5[1..5]<0..31> 1)                        (Type 1.1)
//                  <0>          ：=缺省
//               <1..15>         ：=为本配套标准的标准定义保留(兼容范围)
//              <16..31>2)        ：= 为特定使用保留(专用范围)
//        LFD                    ：=BS1[6]<0..1>                              (Type 6)
//                   <0>         ：=后面还有目录文件
//                   <1>         ：=目录最后文件
//        FOR                     ：=BS1[7]<0..1>                             (Type 6)
//                   <0>          ：=定义文件名
//                   <1>          ：=定义子目录名
//        FA                      ：=BS1[8]<0..1>                             (Type 6)
//                   <0>          ：=文件等待传输
//                   <1>          ：=文件传输巳激活
    int l_i_STATUS=data_parse>>3;  //->8位——右1
    QString l_s_STATUS;
    if(l_i_STATUS==0)
    {
        l_s_STATUS="STATUS=0 缺省";
    }else if(l_i_STATUS>=1&&l_i_STATUS<=15)
    {
        l_s_STATUS="STATUS=1——15 为本配套标准的标准定义保留(兼容范围)";
    }else if (l_i_STATUS>=16&&l_i_STATUS<=31)
          l_s_STATUS="为特定使用保留(专用范围)";

    int l_i_LFD=data_parse>>2;  //->LFD
    QString l_s_LFD;

    if(l_i_LFD==0)
        l_s_LFD="LFD =0  后面还有目录文件 ";
    else
        l_s_LFD="LFD =1 目录最后文件";

    int l_i_FOR=data_parse>>1;  //->FOR
    QString l_s_FOR;

    if(l_i_FOR==0)
        l_s_FOR="FOR =0  定义文件名 ";
    else
        l_s_FOR="FOR =1 定义子目录名";

    int l_i_FA=data_parse;  //->FA
    QString l_s_FA;

    if(l_i_FA==0)
        l_s_FA="FA =0  文件等待传输 ";
    else
        l_s_FA="FA =1 文件传输巳激活";

    QString l_all=" SOF ：＝CP8{STATUS,LFD,FOR,FA}"+l_s_STATUS+l_s_LFD+l_i_FOR+l_i_FA;
  //  qDebug()<<l_all;
    return l_all;
}

//********************************************************************************
//函数名：pParseQOS
//功能：设定命令限定词(QOS)
QString informationWord::pParseQOS(int data_parse)
{
//    QOS                     ：＝CP8{QL,S/E}
//    QL                       ：＝UI7[1..7]<0..127>                        (Type 1.1)
//                  <0>            ：=缺省
//               <1..63>            ：=为本配套标准的标准定义保留(兼容范围)
//              <64..127>           ：= 为特定使用保留(专用范围)
//    S/E=                     ：=BS1[8]<0..1>                            (Type 6)
//                  <0>            ：=执行
//                  <1>            ：＝选择
    int l_i_UI7=data_parse>>1;
    QString l_s_UI7;

    if(l_i_UI7==0){
        l_s_UI7="UC=0：缺省";
    }else if(l_i_UI7>=1&&l_i_UI7<=63)
    {
        l_s_UI7="UI7=<1..63>：=为本配套标准的标准定义保留(兼容范围)";
    }else if(l_i_UI7>=64&&l_i_UI7<=127)
    {
        l_s_UI7="UI7=<64..127> ：=为特定使用保留(专用范围)";
    }

    //->BS1
   int l_i_BSI=data_parse%2;
   QString l_s_BSI;

   if(l_i_BSI==0)
       l_s_BSI="BSI =0  节准备就绪 ";
   else
       l_s_BSI="BSI =1  节未准备就绪 ";

   QString l_all="  SRQ ：＝CP8{UI7[1..7],BS1[8]}  "+l_s_UI7+l_s_BSI;
 //  qDebug()<<l_all;
   return l_all;
}

//********************************************************************************
//函数名：pParseSCD
//功能：状态和状态变位检出(SCD)
QString informationWord::pParseSCD(int data_parse)
{
//    SCD                     ：＝CP32{ST,CD}
//    ST                       ：＝BS16[1..16]                             (Type 6)
//           BS16[n]                 ：=STn=位序为n位的状态位
//           STn<0>                ：=开
//           STn<1>                ：=合
//    CD                       ：＝BS16[17..32]                              (TYPE 6)
//           BS16[n]                   ：=CDn=位序为n+16位的状态变位检出
//           CDn<0>                ：=上次报告后未检出到状态变化
//           CDn<1>                ：=上次报告后至少检出到一次状态变化

}


//********************************************************************************
//函数名：parseInformationAddress
//功能：解析信息对象地址
QString informationWord::parseInformationAddress(const QString &data_parse)
{
    QString informationAddress=data_parse.right(2)+data_parse.mid(2,2)+data_parse.left(2);
    int tmp=informationAddress.toInt(&ok,16);
    return tr("%1:信息体地址：%2")
            .arg(data_parse)
            .arg(tmp);

}




